package pc

import (
	. "chess_platform/internal/common"
	"chess_platform/models/client"
	"chess_platform/models/pc"
	"fmt"
	"time"
)

//[pc]monitor:数据监控
type MonitorController struct {
	GrantController
}

func (b *MonitorController) URLMapping() {
	//player-count:注册玩家统计
	b.Mapping("ListRegisterCount", b.ListRegisterCount)
	//player-online:玩家在线表
	b.Mapping("ListOnlinePlayer", b.ListOnlinePlayer)
	b.Mapping("KickPlayer", b.KickPlayer)
	b.Mapping("ForceSubmitLog", b.ForceSubmitLog)
	//player-graph:玩家在线图
	b.Mapping("ListOnlinePlayerGraph", b.ListOnlinePlayerGraph)

	//table:房间(桌子)列表
	b.Mapping("ListTable", b.ListTable)
	b.Mapping("DismissTable", b.DismissTable)

	//club:亲友圈列表
	b.Mapping("ListClub", b.ListClub)
	b.Mapping("ChangeClubStatus", b.ChangeClubStatus)
	b.Mapping("ClubDetail", b.ClubDetail)
	b.Mapping("ListClubFloor", b.ListClubFloor)
	b.Mapping("ListClubMember", b.ListClubMember)
	b.Mapping("ChangeClubHost", b.ChangeClubHost)
}

// @Title 每隔半小时的用户注册数
// @Description 每隔半小时的用户注册数
// @Param   start_time    body   int     true       "开始时间"
// @Param   end_time      body   int     true       "结束时间"
// @Success 0 {object} []
// @router /player-count/list-register-count [post]
func (b *MonitorController) ListRegisterCount() {
	var p ListDayParams
	if !b.DecodeParams(&p) {
		return
	}
	if p.EndTime < p.StartTime {
		b.Res.Code = Fail
		b.Res.Msg = MsgErrStartTimeOverEndTime
		b.Response()
		return
	}
	if p.StartTime == 0 && p.EndTime == 0 {
		now := time.Now().Unix()
		p.EndTime = now
		p.StartTime = now - 10*86400 //查10天的数据
	}

	users, err := pc.ListRegisterCount(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = users
	b.ResponseSuccess()
}

// @Title 在线游戏玩家列表(此时此刻在线的,实时的)
// @Description 在线游戏玩家列表(此时此刻在线的,实时的)
// @Param   page_size       body   int     true       "每页显示数量"
// @Param   page_index   	body   int     true       "第几页"
// @Param   uid          	body   int     false      "玩家用户id"
// @Param   username     	body   string  false      "玩家用户昵称"
// @Param   club_name    	body   string  false      "俱乐部昵称"
// @Param   club_password   body   int     false      "俱乐部密码"
// @Param   table_password 	body   string  false      "桌子密码"
// @Success 0 {object} [] 玩家列表
// @router /player-online/list-online-player [post]
func (b *MonitorController) ListOnlinePlayer() {
	type Params struct {
		ListParams
		Uid           int64  `json:"uid"`
		Username      string `json:"username"`
		ClubName      string `json:"club_name"`
		ClubPassword  int64  `json:"club_password"`
		TablePassword string `json:"table_password"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	user, count, err := pc.ListOnlinePlayer(p.ListParams, p.Uid, p.ClubPassword, p.Username, p.ClubName, p.TablePassword)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = user
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 踢玩家下线
// @Description 踢玩家下线
// @Param   uid          	body   int     false      "玩家用户id"
// @Success 0 {object} [] 玩家列表
// @router /player-online/kick-player [post]
func (b *MonitorController) KickPlayer() {
	type Params struct {
		Uid int64 `json:"uid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	ok := client.KillPlayerFromLobby(p.Uid)
	if !ok {
		b.ResponseFail("游戏服返回失败,踢下线失败")
		return
	}
	b.ResponseSuccess()
}

// @Title 强制玩家提交日志
// @Description 强制玩家提交日志
// @Param   uid            body    int     true      "玩家uid"
// @Success 0 {string} 状态码
// @router /player-online/force-submit-log [post]
func (b *MonitorController) ForceSubmitLog() {
	type Params struct {
		Uid int64 `json:"uid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	ok := client.BroadCastMsgToLobby(0, GenBroadcastMsg(ModuleSys, ActionForceSubmitLog, ""), p.Uid)
	if !ok {
		b.ResponseFail("游戏服务器返回失败,请联系开发人员")
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("强制玩家(uid:%v)提交日志", p.Uid)
	b.NewLog(LogPlayer, OpUpdate, msg, map[string]interface{}{})
}

// @Title 获取在玩玩家(时间与人数)
// @Description 获取在玩玩家(时间与人数)
// @Param   start_time    body   int     true       "开始时间"
// @Param   end_time      body   int     true       "结束时间"
// @Success 0 {object} []
// @router /player-graph/list-online-player-graph [post]
func (b *MonitorController) ListOnlinePlayerGraph() {
	var p ListDayParams
	if !b.DecodeParams(&p) {
		return
	}
	if p.EndTime < p.StartTime {
		b.Res.Code = Fail
		b.Res.Msg = MsgErrStartTimeOverEndTime
		b.Response()
		return
	}
	if p.StartTime == 0 && p.EndTime == 0 {
		now := time.Now().Unix()
		p.EndTime = now
		p.StartTime = now - 30*86400 //查30天的数据
	}

	users, err := pc.ListUserOnlinePlay(p)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	b.Res.Data = users
	b.ResponseSuccess()
}

// @Title 桌子列表
// @Description  桌子列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   passwd       body   string  false      "桌子密码"
// @Param   tableid      body   int     false      "桌子的id"
// @Param   hostid       body   int     false      "房主的id"
// @Param   club_id      body   int     false      "俱乐部密码"
// @Param   club_name    body   string  false      "俱乐部名字"
// @Param   isclose      body   int     false      "状态,-1-表示所有,0未结束1正常结束2过期结束3投票解散"
// @Success 0 {object} []common 桌子列表
// @Failure 399
// @router /table/list-table [post]
func (b *MonitorController) ListTable() {
	type Params struct {
		ListParams
		TableId  int64  `json:"tableid"`
		Passwd   string `json:"passwd"`
		HostId   int64  `json:"hostid"`
		ClubId   int64  `json:"club_id"`
		ClubName string `json:"club_name"`
		IsClose  int64  `json:"isclose"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}

	rc, count, err := pc.ListTable(p.ListParams, p.TableId, p.HostId, p.ClubId, p.IsClose, p.ClubName, p.Passwd)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = rc
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 解散桌子
// @Description  解散桌子
// @Param   tableid     body   int     true       "桌子id"
// @Success 0 {string} 状态码
// @Failure 399
// @router /table/dismiss-table  [post]
func (b *MonitorController) DismissTable() {
	type Params struct {
		TableId int64 `json:"tableid" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	table, err := pc.TableInfoById(p.TableId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	if table == nil {
		b.Res.Count = ErrNotFound
		b.Res.Msg = "桌子不存在"
		b.Response()
		return
	}

	if client.ClosePlayerTable(table.GameType, table.PlayType, p.TableId) {
		b.ResponseSuccess("解散成功")
		msg := fmt.Sprintf("解散房间成功(桌子ID:%v)", p.TableId)
		b.NewLog(LogGameConfig, OpUpdate, msg, map[string]interface{}{})
	} else {
		b.ResponseFail("解散失败,游戏服务器异常")
		msg := fmt.Sprintf("解散房间失败,游戏服务器异常(桌子ID:%v)", p.TableId)
		b.NewLog(LogGameConfig, OpUpdate, msg, map[string]interface{}{})
	}
}

// @Title 亲友圈列表(亲友圈实时的数据)
// @Description 亲友圈列表(亲友圈实时的数据)
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   club_id      body   int     false      "id"
// @Param   password     body   int     false      "亲友圈id(亲友圈密码)"
// @Param   host_id      body   int     false      "创建人id"
// @Param   status       body   int     false      "亲友圈状态"
// @Param   club_name    body   string  false      "俱乐部名字(支持模糊搜索)"
// @Param   user_name    body   string  false      "创建人的名字(支持模糊搜索)"
// @Success 0 {object} []common.Club 亲友圈列表
// @router /club/list-club [post]
func (b *MonitorController) ListClub() {
	type Params struct {
		ListParams
		ClubId   int64  `json:"club_id"`
		Password int64  `json:"password"`
		HostId   int64  `json:"host_id"`
		Status   int64  `json:"status"`
		ClubName string `json:"club_name"`
		UserName string `json:"user_name"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	club, count, err := pc.ListClub(p.ListParams, p.ClubId, p.HostId, p.Status, p.Password, p.UserName, p.ClubName)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = club
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 改变亲友圈状态(正常,解散,冻结)
// @Description 改变亲友圈状态(正常,解散,冻结)
// @Param   id           body   int        true        "亲友圈id"
// @Param   status       body   int        true        "1-正常，2-解散,3-冻结"
// @Param   content      body   int        true        "邮件内容"
// @Success 0 {string}  状态码
// @router /club/change-club-status [post]
func (b *MonitorController) ChangeClubStatus() {
	type Params struct {
		Id      int64  `json:"id" valid:"Required"`
		Status  int64  `json:"status" valid:"Range(1,3)"`
		Content string `json:"content"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	club := map[string]interface{}{
		"status": p.Status,
	}

	o := NewDBOrm(DBChess)
	_, err := client.UpdateClub(club, p.Id, o)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}

	switch p.Status {
	//前端数据传来不会正常的时候再把亲友圈更新为正常
	case ClubNormal:
		content := fmt.Sprintf("%v,系统恢复了亲友圈,亲友圈ID为:%v", p.Content, p.Id)
		client.SendEmailToClubMember(content, "恢复亲友圈", ActionResumeClub, p.Id, o)
	case ClubDismiss:
		content := fmt.Sprintf("%v,系统解散了亲友圈,亲友圈ID为:%v", p.Content, p.Id)
		client.SendEmailToClubMember(content, "解散亲友圈", ActionDismissClub, p.Id, o)

	case ClubFrozen:
		content := fmt.Sprintf("%v,系统冻结了亲友圈,亲友圈ID为:%v", p.Content, p.Id)
		client.SendEmailToClubMember(content, "冻结亲友圈", ActionFrozenClub, p.Id, o)
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("更新亲友圈状态(亲友圈ID:%v)", p.Id)
	b.NewLog(LogClub, OpUpdate, msg, club)
}

// @Title 俱乐部详情
// @Description 俱乐部详情
// @Param   club_id      body   int     false      "id"
// @Success 0 {object} []common.Club 亲友圈列表
// @router /club/club-detail [post]
func (b *MonitorController) ClubDetail() {
	type Params struct {
		ClubId int64 `json:"club_id"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	club, err := pc.ClubById(p.ClubId)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = club
	b.ResponseSuccess()
}

// @Title 俱乐部楼层
// @Description 俱乐部楼层
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   club_id      body   int     false      "id"
// @Param   is_delete    body   int     false      "楼层是否被删除了，-1表示所有,0-未删除的，1-已删除的楼层"
// @Success 0 {object} []common.Club 亲友圈列表
// @router /club/list-club-floor [post]
func (b *MonitorController) ListClubFloor() {
	type Params struct {
		ListParams
		ClubId   int64 `json:"club_id" valid:"Required"`
		IsDelete int64 `json:"is_delete" valid:"Range(-1,1)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	club, count, err := pc.ListClubFloor(p.ListParams, p.ClubId, p.IsDelete)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = club
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 俱乐部成员列表
// @Description 俱乐部成员列表
// @Param   page_size    body   int     true       "每页显示数量"
// @Param   page_index   body   int     true       "第几页"
// @Param   club_id      body   int     false      "id"
// @Param   status       body   int     false      "状态,0-所有, 1-待审核,2-拒绝,3-正常(审核通过),4-禁言,5-已删除"
// @Success 0 {object} []common.Club 亲友圈列表
// @router /club/list-club-member [post]
func (b *MonitorController) ListClubMember() {
	type Params struct {
		ListParams
		ClubId int64 `json:"club_id" valid:"Required"`
		Status int64 `json:"status" valid:"Range(0,5)"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	club, count, err := pc.ListClubMember(p.ListParams, p.ClubId, p.Status)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.Res.Data = club
	b.Res.Count = count
	b.ResponseSuccess()
}

// @Title 改变俱乐部创建人
// @Description 改变俱乐部创建人
// @Param   id             body    int     true      "俱乐部id"
// @Param   new_host  	   body    int     true      "俱乐部新创建人"
// @Success 0 {string} 状态码
// @router /formal/change-club-host [post]
func (b *MonitorController) ChangeClubHost() {
	type Params struct {
		Id      int64 `json:"id" valid:"Required"`
		NewHost int64 `json:"new_host" valid:"Required"`
	}
	var p Params
	if !b.DecodeParams(&p) {
		return
	}
	if !b.ValidParams(&p) {
		return
	}
	err := pc.ChangeClubHost(p.Id, p.NewHost)
	if err != nil {
		LogPc.Error(b.DatabaseError(err.Error()))
		return
	}
	b.ResponseSuccess()
	msg := fmt.Sprintf("更改亲友圈(ID:%v)的创建人为:%v", p.Id, p.NewHost)
	b.NewLog(LogClub, OpUpdate, msg, map[string]interface{}{})
}
